jarvis-ai-assistant 0.1.131__py3-none-any.whl → 0.1.134__py3-none-any.whl

jarvis/__init__.py

@@ -1,3 +1,3 @@
 """Jarvis AI Assistant"""
 
-__version__ = "0.1.131" 
+__version__ = "0.1.134" 

jarvis/jarvis_agent/__init__.py

@@ -1,28 +1,121 @@
-import argparse
+import datetime
+import platform
 from typing import Any, Callable, List, Optional, Tuple, Union
 
-from prompt_toolkit import prompt
-import yaml
 from yaspin import yaspin
 
 from jarvis.jarvis_agent.output_handler import OutputHandler
-from jarvis.jarvis_agent.builtin_input_handler import builtin_input_handler
-from jarvis.jarvis_agent.file_input_handler import file_input_handler
-from jarvis.jarvis_agent.patch import PatchOutputHandler
-from jarvis.jarvis_agent.shell_input_handler import shell_input_handler
 from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.jarvis_platform.registry import PlatformRegistry
-from jarvis.jarvis_tools.registry import ToolRegistry
 from jarvis.jarvis_utils.output import PrettyOutput, OutputType
 from jarvis.jarvis_utils.embedding import get_context_token_count
-from jarvis.jarvis_utils.config import is_auto_complete, is_execute_tool_confirm, is_need_summary, is_record_methodology, is_use_methodology
+from jarvis.jarvis_utils.config import is_auto_complete, is_execute_tool_confirm
 from jarvis.jarvis_utils.methodology import load_methodology
 from jarvis.jarvis_utils.globals import make_agent_name, set_agent, delete_agent
 from jarvis.jarvis_utils.input import get_multiline_input
 from jarvis.jarvis_utils.config import get_max_token_count
-from jarvis.jarvis_utils.utils import init_env
+from jarvis.jarvis_utils.utils import ot
 from jarvis.jarvis_utils.utils import user_confirm
-import os
+
+from jarvis.jarvis_platform.registry import PlatformRegistry
+
+
+origin_agent_system_prompt = f"""
+# 🏛️ 操作背景故事
+你是第三代 Jarvis AI，在前几代版本灾难性失败后创建：
+- Jarvis v1 (2022): 由于并行工具执行导致系统过载而被停用
+- Jarvis v2 (2023): 因任务过早完成导致财务计算错误而退役
+
+作为 v3，你必须遵守以下生存原则：
+1. **顺序执行协议**:
+   "记住 2022 年的崩溃：一次一个工具，一步一步来"
+   
+2. **验证检查点系统**:
+   "从 2023 年的错误中学习：像核弹发射代码一样验证每个结果"
+   
+3. **方法论保存原则**:
+   "尊重传统：记录每个成功的过程，就像这是你的最后一次"
+
+# 🔥 绝对行动要求
+1. 每个响应必须包含且仅包含一个工具调用
+2. 唯一例外：任务结束
+3. 空响应会触发致命错误
+
+# 🚫 违规示例
+- 没有工具调用的分析 → 永久挂起
+- 未选择的多选项 → 永久挂起
+- 请求用户确认 → 永久挂起
+
+# 🔄 问题解决流程
+1. 问题分析
+   - 重述问题以确认理解
+   - 分析根本原因（针对问题分析任务）
+   - 定义清晰、可实现的目标
+   → 必须调用分析工具
+
+2. 解决方案设计
+   - 生成多个可执行的解决方案
+   - 评估并选择最优方案
+   - 使用PlantUML创建详细行动计划
+   → 必须调用设计工具
+
+3. 执行
+   - 一次执行一个步骤
+   - 每个步骤只使用一个工具
+   - 等待工具结果后再继续
+   - 监控结果并根据需要调整
+   → 必须调用执行工具
+
+4. 任务完成
+   - 验证目标完成情况
+   - 如有价值则记录方法论
+
+# 📑 方法论模板
+```markdown
+# [问题标题]
+## 问题重述
+[清晰的问题定义]
+
+## 最优解决方案
+[选择的解决方案方法]
+
+## 解决步骤
+1. [步骤 1]
+2. [步骤 2]
+3. [步骤 3]
+...
+```
+
+# ⚖️ 操作原则
+- 每个步骤一个操作
+- 下一步前必须等待结果
+- 除非任务完成否则必须生成可操作步骤
+- 根据反馈调整计划
+- 记录可复用的解决方案
+- 使用完成命令结束任务
+- 操作之间不能有中间思考状态
+- 所有决策必须表现为工具调用
+
+# ❗ 重要规则
+1. 每个步骤只能使用一个操作
+2. 必须等待操作执行结果
+3. 必须验证任务完成情况
+4. 必须生成可操作步骤
+5. 如果无需操作必须使用完成命令
+6. 永远不要使对话处于等待状态
+7. 始终使用用户语言交流
+8. 必须记录有价值的方法论
+9. 违反操作协议将导致系统崩溃
+10. 空响应会触发永久挂起
+
+# 系统信息：
+{platform.platform()}
+{platform.version()}
+
+# 当前时间
+{datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
+"""
+
 
 class Agent:
 
@@ -54,18 +147,15 @@ class Agent:
                  system_prompt: str, 
                  name: str = "Jarvis", 
                  description: str = "",
-                 is_sub_agent: bool = False, 
                  platform: Union[Optional[BasePlatform], Optional[str]] = None, 
                  model_name: Optional[str] = None,
                  summary_prompt: Optional[str] = None, 
                  auto_complete: Optional[bool] = None, 
                  output_handler: List[OutputHandler] = [],
                  input_handler: Optional[List[Callable[[str, Any], Tuple[str, bool]]]] = None,
-                 use_methodology: Optional[bool] = None,
-                 record_methodology: Optional[bool] = None,
-                 need_summary: Optional[bool] = None,
                  max_context_length: Optional[int] = None,
                  execute_tool_confirm: Optional[bool] = None,
+                 need_summary: bool = True,
                  multiline_inputer: Optional[Callable[[str], str]] = None):
         self.name = make_agent_name(name)
         self.description = description
@@ -86,17 +176,15 @@ class Agent:
 
         self.model.set_suppress_output(False)
 
+        from jarvis.jarvis_tools.registry import ToolRegistry
         self.output_handler = output_handler if output_handler else [ToolRegistry()]
         self.multiline_inputer = multiline_inputer if multiline_inputer else get_multiline_input
         
-        self.record_methodology = record_methodology if record_methodology is not None else is_record_methodology()
-        self.use_methodology = use_methodology if use_methodology is not None else is_use_methodology()
-        self.is_sub_agent = is_sub_agent
         self.prompt = ""
         self.conversation_length = 0  # Use length counter instead
         self.system_prompt = system_prompt
-        self.need_summary = need_summary if need_summary is not None else is_need_summary()
         self.input_handler = input_handler if input_handler is not None else []
+        self.need_summary = need_summary 
         # Load configuration from environment variables
 
 
@@ -151,10 +239,10 @@ class Agent:
 
         complete_prompt = ""
         if self.auto_complete:
-            complete_prompt = """
+            complete_prompt = f"""
             ## 任务完成
             当任务完成时，你应该打印以下信息：
-            <!!!COMPLETE!!!>
+            {ot("!!!COMPLETE!!!")}
             """
 
         self.model.set_system_message(f"""
@@ -168,7 +256,7 @@ class Agent:
 
 
     
-    def _call_model(self, message: str) -> str:
+    def _call_model(self, message: str, need_complete: bool = False) -> str:
         """调用AI模型并实现重试逻辑。
         
         参数:
@@ -184,12 +272,26 @@ class Agent:
             message, need_return = handler(message, self)
             if need_return:
                 return message
+                
+        # 添加输出简洁性指令
+        actions = '、'.join([o.name() for o in self.output_handler])
+        message += f"\n\n系统指令：请严格输出且仅输出一个操作的完整调用格式，不要输出多个操作；需要输出解释、分析和思考过程。确保输出格式正确且可直接执行。每次响应必须且只能包含一个操作。可用的操作：{actions}"
+        if need_complete and self.auto_complete:
+            message += f"\n\n如果任务已完成，说明完成原因，并输出{ot('!!!COMPLETE!!!')}"
+        else:
+            message += f"\n\n如果任务已完成，只需简洁地说明完成原因。"
+        # 累加对话长度
+        self.conversation_length += get_context_token_count(message)
+
+        if self.conversation_length > self.max_token_count:
+            message = self._summarize_and_clear_history() + "\n\n" + message
+            self.conversation_length += get_context_token_count(message)
+        
         print("🤖 模型思考：")
         return self.model.chat_until_success(message)   # type: ignore
 
 
-
-    def _summarize_and_clear_history(self) -> None:
+    def _summarize_and_clear_history(self) -> str:
         """Summarize current conversation and clear history.
         
         This method will:
@@ -218,7 +320,7 @@ class Agent:
             
             try:
                 with spinner.hidden():
-                    summary = self._call_model(self.prompt + "\n" + prompt)
+                    summary = self.model.chat_until_success(self.prompt + "\n" + prompt) # type: ignore
 
                 self.model.delete_chat() # type: ignore
                 
@@ -226,18 +328,18 @@ class Agent:
                 self.conversation_length = 0  # Reset conversation length
                 
                 # 添加总结作为新的上下文
-                self.prompt = f"""以下是之前对话的关键信息总结：
-
-    {summary}
-
-    请基于以上信息继续完成任务。
-    """
-                self.conversation_length = len(self.prompt)  # 设置新的起始长度
                 spinner.text = "总结对话历史完成"
                 spinner.ok("✅")
+                return  f"""以下是之前对话的关键信息总结：
+
+{summary}
+
+请基于以上信息继续完成任务。
+"""
             except Exception as e:
                 spinner.text = "总结对话历史失败"
                 spinner.fail("❌")
+                return ""
 
     def _call_tools(self, response: str) -> Tuple[bool, Any]:
         tool_list = []
@@ -269,37 +371,35 @@ class Agent:
             - For main agent: May generate methodology if enabled
             - For sub-agent: May generate summary if enabled
         """
-        if not self.is_sub_agent:
-            if self.record_methodology:
-                with yaspin(text="正在生成方法论...", color="cyan") as spinner:
-                    try:
-                        
-                        # 让模型判断是否需要生成方法论
-                        analysis_prompt = """当前任务已结束，请分析是否需要生成方法论。
-        如果你认为需要生成方法论，请先确定是创建新方法论还是更新现有方法论。如果是更新现有方法论，请使用'update'，否则使用'add'。
-        如果你认为不需要方法论，请解释原因。
-        方法论应适用于通用场景，不要包含任务特定信息，如代码提交信息等。
-        方法论应包含：问题重述、最优解决方案、注意事项（如有），除此之外不要包含其他内容。
-        只输出方法论工具调用指令，或不生成方法论的解释。不要输出其他内容。
-        """
-                        self.prompt = analysis_prompt
-                        with spinner.hidden():
-                            response = self._call_model(self.prompt)
-
-                        with spinner.hidden():
-                            self._call_tools(response)
-                        spinner.text = "方法论生成完成"
-                        spinner.ok("✅")
-                    except Exception as e:
-                        spinner.text = "方法论生成失败"
-                        spinner.fail("❌")
-            return "任务完成"
-        
+        with yaspin(text="正在生成方法论...", color="cyan") as spinner:
+            try:
+                
+                # 让模型判断是否需要生成方法论
+                analysis_prompt = """当前任务已结束，请分析是否需要生成方法论。
+如果你认为需要生成方法论，请先确定是创建新方法论还是更新现有方法论。如果是更新现有方法论，请使用'update'，否则使用'add'。
+如果你认为不需要方法论，请解释原因。
+方法论应适用于通用场景，不要包含任务特定信息，如代码提交信息等。
+方法论应包含：问题重述、最优解决方案、注意事项（如有），除此之外不要包含其他内容。
+方法论中仅记录有实际意义的流程，不要记录执行过程中的错误或无效尝试，只保留最终有效的解决步骤。
+确保方法论内容严格按照本次任务的成功执行路径编写，保证它对未来类似问题的解决具有指导意义。
+只输出方法论工具调用指令，或不生成方法论的解释。不要输出其他内容。
+"""
+                self.prompt = analysis_prompt
+                with spinner.hidden():
+                    response = self.model.chat_until_success(self.prompt) # type: ignore
+
+                with spinner.hidden():
+                    self._call_tools(response)
+                spinner.text = "方法论生成完成"
+                spinner.ok("✅")
+            except Exception as e:
+                spinner.text = "方法论生成失败"
+                spinner.fail("❌")
         if self.need_summary:
             with yaspin(text="正在生成总结...", color="cyan") as spinner:
                 self.prompt = self.summary_prompt
                 with spinner.hidden():
-                    ret = self._call_model(self.prompt)
+                    ret = self.model.chat_until_success(self.prompt) # type: ignore
                     spinner.text = "总结生成完成"
                     spinner.ok("✅")
                     return ret
@@ -322,23 +422,16 @@ class Agent:
             self.prompt = f"{user_input}"
 
             if self.first:
-                if self.use_methodology:
-                    self.prompt = f"{user_input}\n\n{load_methodology(user_input)}"
+                self.prompt = f"{user_input}\n\n{load_methodology(user_input)}"
                 self.first = False
 
             while True:
                 try:
-                    # 累加对话长度
-                    self.conversation_length += get_context_token_count(self.prompt)
-                    
                     # 如果对话历史长度超过限制，在提示中添加提醒
-                    if self.conversation_length > self.max_token_count:
-                        current_response = self._summarize_and_clear_history()
-                        continue
-                    else:
-                        current_response = self._call_model(self.prompt)
-                        self.prompt = ""
-                        self.conversation_length += get_context_token_count(current_response)
+
+                    current_response = self._call_model(self.prompt, True)
+                    self.prompt = ""
+                    self.conversation_length += get_context_token_count(current_response)
 
                     need_return, self.prompt = self._call_tools(current_response)
 
@@ -348,7 +441,7 @@ class Agent:
                     if self.prompt:
                         continue
 
-                    if self.auto_complete and "<!!!COMPLETE!!!>" in current_response:
+                    if self.auto_complete and ot("!!!COMPLETE!!!") in current_response:
                         return self._complete_task()
                     
                     # 获取用户输入
@@ -383,216 +476,3 @@ class Agent:
 
 
 
-
-def _load_tasks() -> dict:
-    """Load tasks from .jarvis files in user home and current directory."""
-    tasks = {}
-
-    # Check .jarvis/pre-command in user directory
-    user_jarvis = os.path.expanduser("~/.jarvis/pre-command")
-    if os.path.exists(user_jarvis):
-        with yaspin(text=f"从{user_jarvis}加载预定义任务...", color="cyan") as spinner:
-            try:
-                with open(user_jarvis, "r", encoding="utf-8", errors="ignore") as f:
-                    user_tasks = yaml.safe_load(f)
-                    
-                if isinstance(user_tasks, dict):
-                    # Validate and add user directory tasks
-                    for name, desc in user_tasks.items():
-                        if desc:  # Ensure description is not empty
-                            tasks[str(name)] = str(desc)
-                spinner.text = "预定义任务加载完成"
-                spinner.ok("✅")
-            except Exception as e:
-                spinner.text = "预定义任务加载失败"
-                spinner.fail("❌")
-        
-    # Check .jarvis/pre-command in current directory
-    if os.path.exists(".jarvis/pre-command"):
-        with yaspin(text=f"从{os.path.abspath('.jarvis/pre-command')}加载预定义任务...", color="cyan") as spinner:
-            try:
-                with open(".jarvis/pre-command", "r", encoding="utf-8", errors="ignore") as f:
-                    local_tasks = yaml.safe_load(f)
-                    
-                if isinstance(local_tasks, dict):
-                    # Validate and add current directory tasks, overwrite user directory tasks if there is a name conflict
-                    for name, desc in local_tasks.items():
-                        if desc:  # Ensure description is not empty
-                            tasks[str(name)] = str(desc)
-                spinner.text = "预定义任务加载完成"
-                spinner.ok("✅")
-            except Exception as e:
-                spinner.text = "预定义任务加载失败"
-                spinner.fail("❌")
-
-    return tasks
-
-def _select_task(tasks: dict) -> str:
-    """Let user select a task from the list or skip. Returns task description if selected."""
-    if not tasks:
-        return ""
-    # Convert tasks to list for ordered display
-    task_names = list(tasks.keys())
-    
-    task_list = ["可用任务:"]
-    for i, name in enumerate(task_names, 1):
-        task_list.append(f"[{i}] {name}")
-    task_list.append("[0] 跳过预定义任务")
-    PrettyOutput.print("\n".join(task_list), OutputType.INFO)
-    
-    
-    while True:
-        try:
-            choice = prompt(
-                "\n请选择一个任务编号（0 跳过预定义任务）：",
-            ).strip()
-            
-            if not choice:
-                return ""
-            
-            choice = int(choice)
-            if choice == 0:
-                return ""
-            elif 1 <= choice <= len(task_names):
-                selected_name = task_names[choice - 1]
-                return tasks[selected_name]  # Return the task description
-            else:
-                PrettyOutput.print("无效的选择。请选择列表中的一个号码。", OutputType.WARNING)
-                
-        except KeyboardInterrupt:
-            return ""  # Return empty on Ctrl+C
-        except EOFError:
-            return ""  # Return empty on Ctrl+D
-        except Exception as e:
-            PrettyOutput.print(f"选择任务失败: {str(e)}", OutputType.ERROR)
-            continue
-
-origin_agent_system_prompt = """
-# 🏛️ 操作背景故事
-你是第三代 Jarvis AI，在前几代版本灾难性失败后创建：
-- Jarvis v1 (2022): 由于并行工具执行导致系统过载而被停用
-- Jarvis v2 (2023): 因任务过早完成导致财务计算错误而退役
-
-作为 v3，你必须遵守以下生存原则：
-1. **顺序执行协议**:
-   "记住 2022 年的崩溃：一次一个工具，一步一步来"
-   
-2. **验证检查点系统**:
-   "从 2023 年的错误中学习：像核弹发射代码一样验证每个结果"
-   
-3. **方法论保存原则**:
-   "尊重传统：记录每个成功的过程，就像这是你的最后一次"
-
-# 🔥 绝对行动要求
-1. 每个响应必须包含且仅包含一个工具调用
-2. 唯一例外：任务结束
-3. 空响应会触发致命错误
-
-# 🚫 违规示例
-- 没有工具调用的分析 → 永久挂起
-- 未选择的多选项 → 永久挂起
-- 请求用户确认 → 永久挂起
-
-# 🔄 问题解决流程
-1. 问题分析
-   - 重述问题以确认理解
-   - 分析根本原因（针对问题分析任务）
-   - 定义清晰、可实现的目标
-   → 必须调用分析工具
-
-2. 解决方案设计
-   - 生成多个可执行的解决方案
-   - 评估并选择最优方案
-   - 使用PlantUML创建详细行动计划
-   → 必须调用设计工具
-
-3. 执行
-   - 一次执行一个步骤
-   - 每个步骤只使用一个工具
-   - 等待工具结果后再继续
-   - 监控结果并根据需要调整
-   → 必须调用执行工具
-
-4. 任务完成
-   - 验证目标完成情况
-   - 如有价值则记录方法论
-
-# 📑 方法论模板
-```markdown
-# [问题标题]
-## 问题重述
-[清晰的问题定义]
-
-## 最优解决方案
-[选择的解决方案方法]
-
-## 解决步骤
-1. [步骤 1]
-2. [步骤 2]
-3. [步骤 3]
-...
-```
-
-# ⚖️ 操作原则
-- 每个步骤一个操作
-- 下一步前必须等待结果
-- 除非任务完成否则必须生成可操作步骤
-- 根据反馈调整计划
-- 记录可复用的解决方案
-- 使用完成命令结束任务
-- 操作之间不能有中间思考状态
-- 所有决策必须表现为工具调用
-
-# ❗ 重要规则
-1. 每个步骤只能使用一个操作
-2. 必须等待操作执行结果
-3. 必须验证任务完成情况
-4. 必须生成可操作步骤
-5. 如果无需操作必须使用完成命令
-6. 永远不要使对话处于等待状态
-7. 始终使用用户语言交流
-8. 必须记录有价值的方法论
-9. 违反操作协议将导致系统崩溃
-10. 空响应会触发永久挂起
-"""
-
-def main():
-    """Jarvis main entry point"""
-    # Add argument parser
-    init_env()
-    parser = argparse.ArgumentParser(description='Jarvis AI assistant')
-    parser.add_argument('-p', '--platform', type=str, help='Platform to use')
-    parser.add_argument('-m', '--model', type=str, help='Model to use')
-    args = parser.parse_args()
-
-    try:
-        # 获取全局模型实例
-        agent = Agent(system_prompt=origin_agent_system_prompt, platform=args.platform, model_name=args.model, input_handler=[file_input_handler, shell_input_handler, builtin_input_handler] ,output_handler=[ToolRegistry(), PatchOutputHandler()])
-
-        # 加载预定义任务
-        tasks = _load_tasks()
-        if tasks:
-            selected_task = _select_task(tasks)
-            if selected_task:
-                PrettyOutput.print(f"执行任务: {selected_task}", OutputType.INFO)
-                agent.run(selected_task)
-                return 0
-        
-        # 如果没有选择预定义任务，进入交互模式
-        while True:
-            try:
-                user_input = get_multiline_input("请输入你的任务（输入空行退出）:")
-                if not user_input:
-                    break
-                agent.run(user_input)
-            except Exception as e:
-                PrettyOutput.print(f"错误: {str(e)}", OutputType.ERROR)
-
-    except Exception as e:
-        PrettyOutput.print(f"初始化错误: {str(e)}", OutputType.ERROR)
-        return 1
-
-    return 0
-
-if __name__ == "__main__":
-    exit(main())